Pythoni operator-moodul: võimsad tööriistad funktsionaalseks programmeerimiseks

Programmeerimismaailmas, eriti kui omaks võtta funktsionaalse programmeerimise paradigmad, on esmatähtis oskus väljendada operatsioone puhtal, lühidal ja korduvkasutataval viisil. Kuigi Python on peamiselt objektorienteeritud keel, pakub see tugevat toetust funktsionaalse programmeerimise stiilidele. Selle toe oluline, kuigi mõnikord tähelepanuta jäetud, komponent peitub operator-moodulis. See moodul pakub kogumit tõhusaid funktsioone, mis vastavad Pythoni sisemistele operaatoritele, olles suurepärased alternatiivid lambda-funktsioonidele ning parandades koodi loetavust ja jõudlust.

operator-mooduli mõistmine

operator-moodul defineerib funktsioonid, mis teostavad Pythoni sisseehitatud operaatoritega samaväärseid operatsioone. Näiteks operator.add(a, b) on samaväärne a + b-ga ja operator.lt(a, b) on samaväärne a < b-ga. Need funktsioonid on sageli tõhusamad kui nende operaatoritest vasted, eriti jõudluskriitilistes kontekstides, ja neil on oluline roll funktsionaalse programmeerimise konstruktsioonides nagu map(), filter() ja functools.reduce().

Miks peaksite kasutama operator-mooduli funktsiooni otse operaatori asemel? Peamised põhjused on:

• Ühilduvus funktsionaalse stiiliga: Paljud kõrgemat järku funktsioonid Pythonis (nagu need functools-moodulis) ootavad kutsutavaid objekte. Operaatorfunktsioonid on kutsutavad, mis teeb neist ideaalsed argumendid, mida edasi anda ilma eraldi lambda-funktsiooni defineerimata.
• Loetavus: Teatud keerulistes olukordades võib nimetatud operaatorfunktsioonide kasutamine mõnikord parandada koodi selgust võrreldes keerukate lambda-avaldistega.
• Jõudlus: Teatud operatsioonide puhul, eriti kui neid kutsutakse korduvalt tsüklites või kõrgemat järku funktsioonides, võivad operaatorfunktsioonid pakkuda kerget jõudluse eelist tänu nende C-keeles implementeerimisele.

Põhilised operaatorfunktsioonid

operator-mooduli võib laias laastus liigitada nende esindatavate operatsioonide tüüpide järgi. Uurime mõningaid kõige sagedamini kasutatavaid.

Aritmeetilised operaatorid

Need funktsioonid teostavad standardseid aritmeetilisi arvutusi. Need on eriti kasulikud, kui peate edastama aritmeetilise operatsiooni argumendina teisele funktsioonile.

• operator.add(a, b): Samaväärne a + b-ga.
• operator.sub(a, b): Samaväärne a - b-ga.
• operator.mul(a, b): Samaväärne a * b-ga.
• operator.truediv(a, b): Samaväärne a / b-ga (tõene jagamine).
• operator.floordiv(a, b): Samaväärne a // b-ga (täisarvuline jagamine).
• operator.mod(a, b): Samaväärne a % b-ga (jääk).
• operator.pow(a, b): Samaväärne a ** b-ga (astendamine).
• operator.neg(a): Samaväärne -a-ga (unaarne negatsioon).
• operator.pos(a): Samaväärne +a-ga (unaarne positiivne).
• operator.abs(a): Samaväärne abs(a)-ga.

Näide: operator.add kasutamine koos functools.reduce-ga

Kujutage ette, et peate summeerima kõik elemendid nimekirjas. Kuigi sum() on kõige pythonilikum viis, demonstreerib reduce kasutamine koos operaatorfunktsiooniga selle kasulikkust:

            import operator
from functools import reduce

numbers = [1, 2, 3, 4, 5]

# Kasutades reduce koos operator.add-ga
total = reduce(operator.add, numbers)
print(f"Summa {numbers} on: {total}") # Väljund: Summa [1, 2, 3, 4, 5] on: 15

            

              
                Copy
              
            
          

See on funktsionaalselt samaväärne järgnevaga:

            total_lambda = reduce(lambda x, y: x + y, numbers)
print(f"Summa lambda abil: {total_lambda}") # Väljund: Summa lambda abil: 15

            

              
                Copy
              
            
          

operator.add versiooni eelistatakse sageli selle selguse ja potentsiaalsete jõudluseeliste tõttu.

Võrdlusoperaatorid

Need funktsioonid teostavad võrdlusi kahe operandi vahel.

• operator.lt(a, b): Samaväärne a < b-ga (väiksem kui).
• operator.le(a, b): Samaväärne a <= b-ga (väiksem või võrdne).
• operator.eq(a, b): Samaväärne a == b-ga (võrdne).
• operator.ne(a, b): Samaväärne a != b-ga (mitte võrdne).
• operator.ge(a, b): Samaväärne a >= b-ga (suurem või võrdne).
• operator.gt(a, b): Samaväärne a > b-ga (suurem kui).

Näide: Sõnastike nimekirja sorteerimine konkreetse võtme järgi

Oletame, et teil on nimekiri kasutajaprofiilidest, millest igaüks on esitatud sõnastikuna, ja soovite neid sorteerida nende 'score' (skoori) järgi.

            import operator

users = [
    {'name': 'Alice', 'score': 85},
    {'name': 'Bob', 'score': 92},
    {'name': 'Charlie', 'score': 78}
]

# Sorteeri kasutajad skoori järgi kasutades operator.itemgetter
sorted_users = sorted(users, key=operator.itemgetter('score'))
print("Kasutajad sorteeritud skoori järgi:")
for user in sorted_users:
    print(user)
# Väljund:
# Kasutajad sorteeritud skoori järgi:
# {'name': 'Charlie', 'score': 78}
# {'name': 'Alice', 'score': 85}
# {'name': 'Bob', 'score': 92}

            

              
                Copy
              
            
          

Siin on operator.itemgetter('score') kutsutav, mis sõnastiku saamisel tagastab väärtuse, mis on seotud võtmega 'score'. See on puhtam ja tõhusam kui kirjutada key=lambda user: user['score'].

Loogikatehted

Need funktsioonid teostavad loogilisi operatsioone.

• operator.not_(a): Samaväärne not a-ga.
• operator.truth(a): Tagastab True, kui a on tõene, vastasel juhul False.
• operator.is_(a, b): Samaväärne a is b-ga.
• operator.is_not(a, b): Samaväärne a is not b-ga.

Näide: Väärate (falsy) väärtuste väljafiltreerimine

Saate kasutada operator.truth koos filter()-iga, et eemaldada kõik väärad väärtused (nagu 0, None, tühjad stringid, tühjad nimekirjad) itereeritavast objektist.

            import operator

data = [1, 0, 'hello', '', None, [1, 2], []]

# Filtreeri välja väärad väärtused kasutades operator.truth
filtered_data = list(filter(operator.truth, data))
print(f"Algandmed: {data}")
print(f"Filtreeritud andmed (tõesed väärtused): {filtered_data}")
# Väljund:
# Algandmed: [1, 0, 'hello', '', None, [1, 2], []]
# Filtreeritud andmed (tõesed väärtused): [1, 'hello', [1, 2]]

            

              
                Copy
              
            
          

Bitikaupa operaatorid

Need funktsioonid opereerivad täisarvude üksikutel bittidel.

• operator.and_(a, b): Samaväärne a & b-ga.
• operator.or_(a, b): Samaväärne a | b-ga.
• operator.xor(a, b): Samaväärne a ^ b-ga.
• operator.lshift(a, b): Samaväärne a << b-ga.
• operator.rshift(a, b): Samaväärne a >> b-ga.
• operator.invert(a): Samaväärne ~a-ga.

Näide: Bitikaupa operatsioonide teostamine

            import operator

a = 10 # Binaarne: 1010
b = 4  # Binaarne: 0100

print(f"a & b: {operator.and_(a, b)}") # Väljund: a & b: 0 (Binaarne: 0000)
print(f"a | b: {operator.or_(a, b)}")  # Väljund: a | b: 14 (Binaarne: 1110)
print(f"a ^ b: {operator.xor(a, b)}") # Väljund: a ^ b: 14 (Binaarne: 1110)
print(f"~a: {operator.invert(a)}")     # Väljund: ~a: -11

            

              
                Copy
              
            
          

Järjendi ja vastenduse operaatorid

Need funktsioonid on kasulikud elementidele ligipääsemiseks järjendites (nagu nimekirjad, ennikud, stringid) ja vastendustes (nagu sõnastikud).

• operator.getitem(obj, key): Samaväärne obj[key]-ga.
• operator.setitem(obj, key, value): Samaväärne obj[key] = value-ga.
• operator.delitem(obj, key): Samaväärne del obj[key]-ga.
• operator.len(obj): Samaväärne len(obj)-ga.
• operator.concat(a, b): Samaväärne a + b-ga (järjendite, nagu stringid või nimekirjad, puhul).
• operator.contains(obj, item): Samaväärne item in obj-ga.

operator.itemgetter: võimas tööriist

Nagu sorteerimisnäites vihjatud, on operator.itemgetter spetsialiseeritud funktsioon, mis on uskumatult kasulik. Kui seda kutsutakse ühe või mitme argumendiga, tagastab see kutsutava, mis hangib need elemendid oma operandist. Kui antakse mitu argumenti, tagastab see hangitud elementide enniku.

            import operator

# Ühe elemendi hankimine
get_first_element = operator.itemgetter(0)
my_list = [10, 20, 30]
print(f"Esimene element: {get_first_element(my_list)}") # Väljund: Esimene element: 10

# Mitme elemendi hankimine
get_first_two = operator.itemgetter(0, 1)
print(f"Esimesed kaks elementi: {get_first_two(my_list)}") # Väljund: Esimesed kaks elementi: (10, 20)

# Elementide hankimine sõnastikust
get_name_and_score = operator.itemgetter('name', 'score')
user_data = {'name': 'Alice', 'score': 85, 'city': 'New York'}
print(f"Kasutaja info: {get_name_and_score(user_data)}") # Väljund: Kasutaja info: ('Alice', 85)

            

              
                Copy
              
            
          

operator.itemgetter on ka väga tõhus, kui seda kasutatakse key-argumendina sorteerimisel või teistes funktsioonides, mis aktsepteerivad võtmefunktsiooni.

operator.attrgetter: atribuutidele ligipääsemine

Sarnaselt itemgetter-ile tagastab operator.attrgetter kutsutava, mis hangib atribuudid oma operandist. See on eriti käepärane objektidega töötamisel.

            import operator

class Product:
    def __init__(self, name, price):
        self.name = name
        self.price = price

products = [
    Product('Laptop', 1200),
    Product('Mouse', 25),
    Product('Keyboard', 75)
]

# Hangi kõik tootenimed
get_name = operator.attrgetter('name')
product_names = [get_name(p) for p in products]
print(f"Tootenimed: {product_names}") # Väljund: Tootenimed: ['Laptop', 'Mouse', 'Keyboard']

# Sorteeri tooted hinna järgi
sorted_products = sorted(products, key=operator.attrgetter('price'))
print("Tooted sorteeritud hinna järgi:")
for p in sorted_products:
    print(f"- {p.name}: ${p.price}")
# Väljund:
# Tooted sorteeritud hinna järgi:
# - Mouse: $25
# - Keyboard: $75
# - Laptop: $1200

            

              
                Copy
              
            
          

attrgetter pääseb ligi ka atribuutidele läbi pesastatud objektide, kasutades punktnotatsiooni. Näiteks operator.attrgetter('address.city') hangiks 'city' atribuudi objekti 'address' atribuudist.

Muud kasulikud funktsioonid

• operator.methodcaller(name, *args, **kwargs): Tagastab kutsutava, mis kutsub oma operandil välja meetodi nimega name. See on meetodite vaste itemgetter-ile ja attrgetter-ile.

Näide: meetodi väljakutsumine nimekirjas olevatel objektidel

            import operator

class Greeter:
    def __init__(self, name):
        self.name = name

    def greet(self, message):
        return f"{self.name} ütleb: {message}"

greeters = [Greeter('Alice'), Greeter('Bob')]

# Kutsu greet-meetod välja igal Greeter-objektil
call_greet = operator.methodcaller('greet', 'Tervitused operator-moodulist!')

greetings = [call_greet(g) for g in greeters]
print(greetings)
# Väljund: ['Alice ütleb: Tervitused operator-moodulist!', 'Bob ütleb: Tervitused operator-moodulist!']

            

              
                Copy
              
            
          

operator-moodul funktsionaalse programmeerimise kontekstis

operator-mooduli tõeline jõud avaldub, kui seda kasutatakse koos Pythoni sisseehitatud funktsionaalse programmeerimise tööriistadega nagu map(), filter() ja functools.reduce().

map() ja operator

map(function, iterable, ...)` rakendab funktsiooni igale itereeritava elemendile ja tagastab tulemuste iteraatori. Operaatorfunktsioonid sobivad selleks ideaalselt.

            import operator

numbers = [1, 2, 3, 4, 5]

# Ruuduta iga arv kasutades map-i ja operator.mul-i
squared_numbers = list(map(lambda x: operator.mul(x, x), numbers)) # Võib olla lihtsam: list(map(operator.mul, numbers, numbers)) või list(map(pow, numbers, [2]*len(numbers)))
print(f"Ruudutatud arvud: {squared_numbers}") # Väljund: Ruudutatud arvud: [1, 4, 9, 16, 25]

# Liida igale arvule 10 kasutades map-i ja operator.add-i
added_ten = list(map(operator.add, numbers, [10]*len(numbers)))
print(f"Arvud pluss 10: {added_ten}") # Väljund: Arvud pluss 10: [11, 12, 13, 14, 15]

            

              
                Copy
              
            
          

            import operator

salaries = [50000, 65000, 45000, 80000, 70000]

# Filtreeri palgad, mis on suuremad kui 60000
high_salaries = list(filter(operator.gt, salaries, [60000]*len(salaries)))
print(f"Palgad üle 60000: {high_salaries}") # Väljund: Palgad üle 60000: [65000, 80000, 70000]

# Filtreeri paarisarvud kasutades operator.mod ja lambda (või keerulisemat operaatorfunktsiooni)
even_numbers = list(filter(lambda x: operator.eq(operator.mod(x, 2), 0), [1, 2, 3, 4, 5, 6]))
print(f"Paarisarvud: {even_numbers}") # Väljund: Paarisarvud: [2, 4, 6]

            

              
                Copy
              
            
          

            import operator
from functools import reduce

numbers = [2, 3, 4, 5]

# Arvuta arvude korrutis
product = reduce(operator.mul, numbers)
print(f"Korrutis: {product}") # Väljund: Korrutis: 120

# Leia maksimaalne arv
maximum = reduce(operator.gt, numbers)
print(f"Maksimum: {maximum}") # See ei tööta max-i jaoks ootuspäraselt, vaja on kasutada lambdat või kohandatud funktsiooni max-i jaoks: 
# Kasutades lambdat max-i jaoks:
maximum_lambda = reduce(lambda x, y: x if x > y else y, numbers)
print(f"Maksimum (lambda): {maximum_lambda}") # Väljund: Maksimum (lambda): 5
# Märkus: Maksimumi leidmiseks eelistatakse üldiselt sisseehitatud funktsiooni max().

            

              
                Copy